#ifndef __H_UTIL_M__
#define __H_UTIL_M__

#include <iostream>

#include <string>
#include <vector>
#include <memory>
#include <sstream>
#include <fstream>
#include <mysql/mysql.h>
#include <jsoncpp/json/json.h>

#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
typedef websocketpp::server<websocketpp::config::asio> wsserver_t;


#include "logger.hpp"
using namespace std;
// 封装mysql

class mysql_util
{
public:
    static MYSQL* mysql_create(const string& host, const string& username, const string& password,
                        const string& dbname, uint16_t port = 3306)
    {
        // 初始化mysql句柄
        MYSQL* mysql = mysql_init(NULL);
        if(mysql == NULL)
        {
            ELOG("mysql 服务器初始化失败");
            return NULL;
        }
        // 连接mysql服务器
        if(mysql_real_connect(mysql, host.c_str(), username.c_str(), password.c_str(), dbname.c_str(), port, NULL, 0) == NULL)
        {
            ELOG("连接 mysql服务器失败, 原因：%s", mysql_error(mysql));
            return NULL;
        }
        // 设置当前客⼾端的字符集
        if(mysql_set_character_set(mysql, "utf8") != 0)
        {
            ELOG("设置字符集失败, 原因：%s", mysql_error(mysql));
            return NULL;
        }
        return mysql;
    }
    static bool mysql_execute(MYSQL* mysql, const string& sql)
    {
        // 执行sql语句
        if(mysql_query(mysql, sql.c_str()) != 0)
        {
            ELOG("%s ", sql.c_str());
            ELOG("执行语句失败，原因：%s", mysql_error(mysql));
            return false;
        }
        return true;
    }
    static void mysql_destroy(MYSQL* mysql)
    {
        if(mysql != NULL)   //句柄不为空才释放
        {
            mysql_close(mysql); //关闭连接释放句柄
        }

    }

};
// json工具
class json_util
{
public:
    // 序列化
    static bool serialize(const Json::Value& root, string& str)
    {
        Json::StreamWriterBuilder swb;
        unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
        stringstream ss;
        if(sw->write(root, &ss) != 0)
        {
            ELOG("序列化失败");
            return false;
        }

        str = ss.str();
        return true;
    }
    // 反序列化
    static bool unserialize(const string& str, Json::Value& root)
    {
        Json::CharReaderBuilder crb;
        unique_ptr<Json::CharReader> cr(crb.newCharReader());
        string err;
        if(cr->parse(str.c_str(), str.c_str()+str.size(), &root, &err) == false)
        {
            ELOG("反序列化失败,错误：%s",err.c_str());
            return false;
        }

        return true;
    }
};
// 字符串切割
class string_util
{
public:
    // 切割字符串
    static int split(const string& str, const string& sep, vector<string>& arr)
    {
        size_t pos,start = 0;
        while(start < str.size())
        {
            pos = str.find(sep, start);
            if(pos == string::npos )
            {
                arr.push_back(str.substr(start));
                break;
            }
            if( start == pos )
            {
                start += sep.size();
                continue;
            }
            arr.push_back(str.substr(start, pos - start));
            start = pos + sep.size();
        }
        return arr.size();
    }
};
// 读取文件工具
class file_util
{
public:
    static bool read(const string& filename, string& body)
    {
        // 1.打开文件
        ifstream ifs(filename, ios::binary);
        if(ifs.is_open() == false)
        {
            ELOG("打开 %s 文件失败", filename.c_str());
            return false;
        }
        // 2. 获取文件大小
        size_t filesize = 0;
        ifs.seekg(0, ios::end); //移动到文件末尾位置
        filesize = ifs.tellg();//获取当前文件的位置
        ifs.seekg(0, ios::beg); //移动到开始位置
        body.resize(filesize);
        // 3. 读取文件内容
        ifs.read(&body[0], filesize);
        if(ifs.good() == false)
        {
            ELOG("读取 %s 文件失败", filename);
            ifs.close();
            return false;
        }
        // 4. 关闭文件
        ifs.close();
        return true;
    }
};

#endif